<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
</body>
<script defer>
// promise和async/await区别
// 1 promise是ES6，async/await是ES7
// 2 async/await相对于promise来讲，写法更加优雅
// 3 reject状态：
// promise错误可以通过catch来捕捉，建议尾部捕获错误，
// async/await既可以用.then又可以用try-catch捕捉
function request(num) { // 模拟接口请求
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(num * 2)
    }, 1000)
  })
}

async function fn () {
  const res1 = await request(5)
  const res2 = await request(res1)
  console.log(res2) // 2秒后输出 20
}
async function fnn(){ //async函数return出来的是一个promise对象
    await fn();
    return 2;//注意return后面语句会比await函数先执行
}
console.log(fnn());

let p = new Promise((resolve,reject) => {
   return setTimeout(() => {
      resolve('successful');
    },1000);
}).then(data=>{
  console.log(data,'1');
});
//注意：捕获Promise的结果只有在一个地方捕获，即：在Promise.then捕获之后async函数里的try.catch就不能捕获到了
async function demo() {
    try { //try捕获成功回调
        let result = await p;
        console.log(result,'2');
    }catch(e) { //catch捕获失败回调
        console.log(e);
    }
}

demo();

const ps = new Promise((resolve,reject)=>{
	setTimeout(resolve(1,2))//注意：promise的状态回调函数只能传一个参数，多传接收那里会显示undefined
})
// ps.then(()=>{console.log('resolve')}).catch(()=>{console.log('reject')})//显式的写出catch会正常捕获
ps.then((data1)=>{console.log(data1)},()=>{console.log('reject')})//在.then函数中隐式的catch也会正常捕获---()=>{console.log('reject')}


const promise = new Promise((resolve, reject) => {
  resolve(new Promise((resolve, reject) => {//如果resolve中传入的是另外一个Promise，那么这个新Promise会决定原Promise的状态
    setTimeout(() => {
      resolve('ice')
    }, 1000);
  }))
})

promise.then(res => console.log(res)).finally(()=>{
  console.log('一定要执行');
})

//promise.then函数的返回值
new Promise((res,rej)=>{
  res(88)
}).then(res=>({res})).then(res=>{
 console.log(res);
})

// promise.all的使用
let p1 = new Promise((resolve,reject)=>{
  setTimeout(()=>{
    resolve(1)
  },300)
});
let p2 = new Promise((resolve,reject)=>{
  setTimeout(()=>{
    resolve(2)
  },200)
});
let p3 = new Promise((resolve,reject)=>{
  setTimeout(()=>{
    resolve(3)
  },100)
});
// let wait = Promise.race([p1,p2,p3]);//Promise.race谁先返回数据就返回谁 
// console.log(wait);
Promise.any([p1,p2,p3]).then(res=>{//Promise.any与race类似，只获取第一个状态为fulfilled，如果全部为rejected则报错
  console.log(res);
}).catch(err=>{
  console.log(err);
})

const promise3 = new Promise((resolve, reject) => {});//如果promise没有放回结果则它的状态一直是pending等待状态，且返回为undefined
console.log(promise3);

let obj = Object.create(null,{ //Object.create创建一个纯净的对象，即它的原型没有携带任何属性
  name:{                       //Object.create的两个参数：proto创建对象的原型，表示要继承的对象           
    value: 'James'             //propertiesObject(可选 )也是一个对象，用于对新创建的对象进行初始化
  },
  age:{
    value: '38'
  },
  fn:{
    value: function () {
      return this.name+'-'+this.age 
    }
  }
})
let myObj = Object.create(obj,{name:{ //注意：如果继承的对象中和创建的对象的属性同名则采用就近原则取自身身上的属性
  value:"fish",        // 初始化赋值
  writable:true,       // 是否是可改写的
  configurable:true,   // 是否能够删除，是否能够被修改
  enumerable:true      //是否可以用for in 进行枚举
}});
console.log(myObj.fn());


// 剩余参数ES6新增
// function fnn(a,...b){
//     console.log(a,b);
// }
// fnn(1,2,3,4,5)

// const obj = {
//   name: '林三心',
//   age: 22,
//   gender: '男'
// }

// // const keys = Object.keys(obj).map((key,item)=>{
// //         console.log(key,obj[key]);//key=>属性名    obj[key]=>属性值
// // });
// const keys = Object.entries(obj);
// console.log(keys) // [ 'name', 'age', 'gender' ]

// const mul = x => y => z =>{
//   console.log(x,y,z);
//   return x * y * z
// };
// console.log(mul(1)(2)(10)) // 20
</script>
</html>